#pragma once
#include <iostream>
#include <string>
#include<json/json.h>
//#define Myself 0
// 序列化和反序列化的功能
const std::string blank_space_sep = " ";
const std::string protocol_sep = "\n";

std::string Encode(std::string &content)
{
    // 封装报头  len \n x op y\n
    std::string package = std::to_string(content.size());
    package += protocol_sep;
    package += content;
    package += protocol_sep;

    return package;
}

//提取并检查报文是否完整
// len\n 报文 y\n 用于网络通信
bool Decode(std::string &package,std::string*content)
{
    std::size_t pos = package.find(protocol_sep);
    if (pos == std::string::npos)
        return false;
    std::string len_str = package.substr(0, pos);
    std::size_t len = std::stoi(len_str);

    size_t total_len = len_str.size() + len + 2; // 理论上报文的值
    // 传入的报文小于理论值，说明发生了丢包
    if (package.size() < total_len)
        return false;

    *content=package.substr(pos+1,len);
    //提取到有效的信息后，就要移除流中这条信息的内容
    package.erase(0,total_len);
    return true;
}
// 请求
class Request
{
public:
    Request(int data1, int data2, char oper)
        : x(data1), y(data2), op(oper)
    {
    }

    Request()
    {
    }

    ~Request()
    {
    }

    // 序列化
    bool Serialize(std::string *out)
    {
#ifdef Myself
        // 构建报文的有效载荷  x op y
        std::string s = std::to_string(x);
        s += blank_space_sep;
        s += op;
        s += blank_space_sep;
        s += std::to_string(y);
        *out = s;
        return true;
#else
        Json::Value root;
        root["x"]=x;
        root["y"]=y;
        root["op"]=op;
        //Json::FastWriter w;
        Json::StyledWriter w;
        *out=w.write(root);
        return true;
#endif
    }
    // 反序列化  x op y
    bool Deseralize(const std::string &in)
    {
#ifdef Myself
        size_t left = in.find(blank_space_sep);
        if (left == std::string::npos)
            return false;
        std::string part_x = in.substr(0, left); // 左闭右开

        size_t right = in.rfind(blank_space_sep);
        if (right == std::string::npos)
            return false;
        std::string part_y = in.substr(right + 1);

        if (left + 2 != right)
            return false;
        op = in[left + 1];
        x = std::stoi(part_x);
        y = std::stoi(part_y);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in,root);
        x=root["x"].asInt();
        y=root["y"].asInt();
        op=root["op"].asInt();
        return true;
#endif
    }

    void DebugPrint()
    {
        std::cout<<"请求构建完成："<<x<<op<<y<<"=?"<<std::endl;
    }
public:
    int x;
    int y;
    char op; //+ - * / %
};

// 应答
class Response
{
public:
    Response(int res, int c)
        : result(res), code(c)
    {
    }

    Response()
    {

    }

    ~Response()
    {
    }

    // 序列化
    bool Serialize(std::string *out)
    {
#ifdef Myself
        // result code
        // 构建报文的有效载荷
        std::string s = std::to_string(result);
        s += blank_space_sep;
        s += std::to_string(code);
        *out = s;
        return true;
#else
        Json::Value root;
        root["result"]=result;
        root["code"]=code;
        //Json::FastWriter w;
        Json::StyledWriter w;
        *out=w.write(root);
        return true;
#endif
    }

    // 反序列化
    bool Deserialize(const std::string &in)
    {
#ifdef Myself
        size_t pos = in.find(blank_space_sep);
        if (pos == std::string::npos)
            return false;
        std::string part_left = in.substr(0, pos);
        std::string part_right = in.substr(pos + 1);

        result = std::stoi(part_left);
        code = std::stoi(part_right);
        return true;
#else
        Json::Value root;
        Json::Reader r;
        r.parse(in,root);

        result=root["result"].asInt();
        code=root["code"].asInt();
        return true;
#endif    
    }

    void DebugPrint()
    {
        std::cout<<"结果响应完成,result:"<<result<<",code:"<<code<<std::endl;
    }
public:
    int result;
    int code; //
};